home *** CD-ROM | disk | FTP | other *** search
/ QRZ! Ham Radio 4 / QRZ Ham Radio Callsign Database - Volume 4.iso / files / tcpip / amiga / asrc29p.lha / digger.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-12-29  |  11.6 KB  |  490 lines
  1. /* Digger functions.
  2.    08/07/90, Bob Applegate wa2zzx */
  3.  
  4. #include <stdio.h>
  5. #include <ctype.h>
  6. #include <exec/types.h>
  7. #include <time.h>
  8. #include "global.h"
  9. #include "cmdparse.h"
  10. #include "commands.h"
  11. #include "proc.h"
  12. #include "files.h"
  13. #include "smtp.h"
  14. #include <dos.h>
  15. #include <ios1.h>
  16. #include <proto/dos.h>
  17. #include "bm.h"
  18. #include "ax25.h"
  19.  
  20. static int mailcat __ARGS((char *file,char *explanation));
  21. static int AddSMTPHeader __ARGS((FILE *tfile, char *explanation));
  22.  
  23. extern char *mbxtime __ARGS((char *line));
  24. extern char *Organ, *RHdr;
  25.  
  26. int DiggerLock, MaxSeg = 3000, MaxReq = 5, reqcnt = 0;
  27. extern char *Digger, *DiggerC;
  28. char whoto[80], *tonic;
  29. int FoundRColon;
  30.  
  31. static void DiggerProcess __ARGS(());
  32. static int CheckForStuff __ARGS((int argc,char *argv[],void *p));
  33. static struct proc *ProcessPointer;
  34.  
  35. extern int mlock __ARGS((char *dir,char *id));
  36. extern int rmlock __ARGS((char *dir,char *id));
  37.  
  38. static int dgstart __ARGS((int argc,char *argv[],void *p));
  39. static int dgstop __ARGS((int argc,char *argv[],void *p));
  40. static int dgkick __ARGS((int argc,char *argv[],void *p));
  41. static int dgsegsiz __ARGS((int argc,char *argv[],void *p));
  42. static int dgmaxreq __ARGS((int argc,char *argv[],void *p));
  43.  
  44. static int dgban __ARGS((int argc,char *argv[],void *p));
  45. static int dgunban __ARGS((int argc,char *argv[],void *p));
  46.  
  47. /* Digger: Banned Users */
  48. struct br {
  49.     struct br *prev;
  50.     struct br *next;
  51.     char addr[AXALEN];
  52.     int bancnt;
  53. };
  54.  
  55. struct br *Br;
  56.  
  57. static struct cmds Diggercmds[] = {
  58.    "ban",         dgban,       0, 0, NULLCHAR,
  59.    "kick",        dgkick,      0, 0, NULLCHAR,
  60.    "maxrequests", dgmaxreq,    0, 0, NULLCHAR,
  61.    "on",          dgstart,     0, 0, NULLCHAR,
  62.    "off",         dgstop,      0, 0, NULLCHAR,
  63.    "segmentsize", dgsegsiz,    0, 0, NULLCHAR,
  64.    "unban",       dgunban,     0, 0, NULLCHAR,
  65.    NULLCHAR
  66. };
  67.  
  68. int dodigger(argc,argv,p)
  69. int argc;
  70. char *argv[];
  71. void *p;
  72. {
  73.    return subcmd(Diggercmds,argc,argv,p);
  74. }
  75.  
  76. static int dgstart(argc,argv,p)
  77. int argc;
  78. char *argv[];
  79. void *p;
  80. {
  81.    ProcessPointer = newproc("Digger",1024,DiggerProcess,0,NULL,NULL);
  82.  
  83.    return 0;
  84. }
  85.  
  86. static int dgstop(argc,argv,p)
  87. int argc;
  88. char *argv[];
  89. void *p;
  90. {
  91.    killproc(ProcessPointer);
  92.  
  93.    return 0;
  94. }
  95.  
  96. static int dgkick(argc,argv,p)
  97. int argc;
  98. char *argv[];
  99. void *p;
  100. {
  101.    psignal(&DiggerLock,1);
  102.  
  103.    return 0;
  104. }
  105.  
  106. static int dgsegsiz(argc,argv,p)
  107. int argc;
  108. char *argv[];
  109. void *p;
  110. {
  111.    if(argc > 1)
  112.       MaxSeg = atoi(argv[1]);
  113.    else
  114.       tprintf("Maximum Message Segment: %d Bytes\n",MaxSeg);
  115.  
  116.    return 0;
  117. }
  118.  
  119. static int dgmaxreq(argc,argv,p)
  120. int argc;
  121. char *argv[];
  122. void *p;
  123. {
  124.    if(argc > 1)
  125.       MaxReq = atoi(argv[1]);
  126.    else
  127.       tprintf("Requests per Message: %d\n",MaxReq);
  128.  
  129.    return 0;
  130. }
  131.  
  132. static int dgban(argc,argv,p)
  133. int argc;
  134. char *argv[];
  135. void *p;
  136. {
  137.    register struct br *bp;
  138.  
  139.    if (argc < 2) {
  140.       tprintf("Banned users: ");
  141.       if(Br != NULLLQ)
  142.          for(bp = Br;bp != NULLLQ;bp = bp->next)
  143.             tprintf(" %s(%d)",bp->addr,bp->bancnt);
  144.       else
  145.          tprintf(" Empty");
  146.       tprintf("\n");
  147.    } else {
  148.       bp = (struct br *)callocw(1,sizeof(struct br));
  149.       memcpy(bp->addr,argv[1],AXALEN);
  150.       bp->bancnt = atoi(argv[2]) == 0 ? 1 : atoi(argv[2]);
  151.       bp->next = Br;
  152.       if(bp->next != NULLLQ)
  153.          bp->next->prev = bp;
  154.       Br = bp;
  155.       tprintf("Digger: '%s' Banned for %d\n",
  156.                argv[1],
  157.                atoi(argv[2]) == 0 ? 1 : atoi(argv[2]));
  158.    }
  159.  
  160.    return 0;
  161. }
  162.  
  163. static int dgunban(argc,argv,p)
  164. int argc;
  165. char *argv[];
  166. void *p;
  167. {
  168.    register struct br *bp;
  169.  
  170.    if (argc < 2) 
  171.       tprintf("string missing!\n");
  172.    else {
  173.       for(bp = Br;bp != NULLLQ;bp = bp->next)
  174.          if(strstr(argv[1],bp->addr))
  175.             break;
  176.  
  177.       if(bp == NULLLQ) {
  178.          tprintf("Not found\n");
  179.          return 1;
  180.       }
  181.  
  182.       if(bp->prev != NULLLQ)
  183.          bp->prev->next = bp->next;
  184.       else
  185.          Br = bp->next;
  186.       if(bp->next != NULLLQ)
  187.          bp->next->prev = bp->prev;
  188.  
  189.       tprintf("Digger: '%s' unbanned\n",argv[1]);
  190.    }
  191.    return 0;
  192. }
  193.  
  194. /** This is the function to handle the interface to the smtp server.
  195.  ** It waits for a resume, then processes everything on the list. */
  196. static void DiggerProcess()
  197. {
  198.    for (;;) {
  199.       pwait(&DiggerLock);   /* wait for something to do... */
  200.       CheckForStuff(NULL,NULLCHAR,NULL);   /* ...then do it */
  201.    }
  202. }
  203.  
  204. static int dgretr __ARGS((int argc,char *argv[],void *p));
  205. static int sendhelp __ARGS((int argc,char *argv[],void *p));
  206. static int sendindex __ARGS((int argc,char *argv[],void *p));
  207. static int listarchives __ARGS((int argc,char *argv[],void *p));
  208.  
  209. static struct cmds diggercmds[] =  {
  210.    "archives",  listarchives, 0, 0, NULLCHAR,
  211.    "help",      sendhelp,     0, 0, NULLCHAR,
  212.    "index",     sendindex,    0, 1, NULLCHAR,
  213.    "retrieve",  dgretr,       0, 1, NULLCHAR,
  214.    NULLCHAR
  215. };
  216.  
  217. /** This function is responsible for reading in mail sent to Digger
  218.  ** and processing the commands. */
  219. static int CheckForStuff(argc,argv,p)
  220. int argc;
  221. char *argv[];
  222. void *p;
  223. {
  224.    register struct br *bp;
  225.    char *CLine, filename[128], *cp;
  226.    int result;
  227.    FILE *fp;
  228.  
  229.    fflush(stdout);
  230.    while (mlock(Mailspool,"Digger"))   /* until we get the lock */
  231.       pause(10 * 1000 / MSPTICK);   /* wait 10 seconds */
  232.    fflush(stdout);
  233.    sprintf(filename,"%s/%s",Mailspool,"Digger.txt");
  234.    fp = fopen(filename,"r");
  235.    if (fp == NULL) {
  236.       (void) rmlock(Mailspool,"Digger");   /* remove our hold on it */
  237.       return 0;
  238.    }
  239.  
  240.    strcpy(whoto, "Postmaster");
  241.  
  242.    reqcnt = 0;
  243.    FoundRColon = 0;
  244.    CLine = mallocw(BUFSIZ);
  245.    while (fgets(CLine,BUFSIZ,fp) != NULLCHAR) {
  246.       rip(CLine);
  247.  
  248.       if (strnicmp(CLine,"Reply-To: ",10) == 0) {
  249.          strcpy(whoto, getaddress(CLine,0));
  250.       } else if (strnicmp(CLine,"From: ",6) == 0) {
  251.          strcpy(whoto, getaddress(CLine,0));
  252.       }
  253.  
  254.       if (strnicmp(CLine,"R:",2) == 0) {
  255.          FoundRColon = 1;
  256.          tonic = strstr(strdup(CLine),"@");
  257.          if((cp=strchr(tonic,' ')) != NULLCHAR)
  258.             *cp = '\0';
  259.       }
  260.  
  261.       for(bp = Br;bp != NULLLQ;bp = bp->next)
  262.          if(strstr(whoto, bp->addr)) {
  263.             mainlog(-1,"Digger rejected request from '%s'", whoto);
  264.             goto rejlab;
  265.          }
  266.  
  267.       if(strlen(CLine) > 0) 
  268.          if((result = cmdparse(diggercmds, CLine, p)) == 0);
  269.    }
  270. rejlab:
  271.    free(CLine);
  272.    fclose(fp);
  273.  
  274.    unlink(filename);
  275.    rmlock(Mailspool,"Digger");   /* remove our hold on it */
  276.  
  277.    return 0;
  278. }
  279.  
  280. static int dgretr(argc,argv,p)
  281. int argc;
  282. char *argv[];
  283. void *p;
  284. {
  285.    FILE *in;
  286.    char buf[100], command[100], error[100], *archive, *specific;
  287.  
  288.    specific = (argv[1] == NULLCHAR) ? NULL : argv[1];
  289.    archive = (argv[2] == NULLCHAR) ? "DataBase" : argv[2];
  290.  
  291.    mainlog(-1,"Digger: Retrieve '%s' From '%s' For '%s'",
  292.                specific, archive, whoto);
  293.  
  294.    sprintf(error,"%s/error", Digger);
  295.    if(reqcnt < MaxReq) 
  296.       if(specific != NULL) {
  297.          if(strstr(specific,"*") != NULL)
  298.             mailcat(error,"Wild Cards Not Permitted!");
  299.          else {
  300.             sprintf(buf,"%s/%s", DiggerC, specific);
  301.             if((in = fopen(buf,READ_TEXT)) != NULLFILE) {
  302.                fclose(in);
  303.                mailcat(buf,specific);
  304.             } else {
  305.                sprintf(command,"LHA >nil: -N -n -m x %s/%s %s/ %s",
  306.                     Digger, archive, DiggerC, specific);
  307.                if (!Execute(command, 0, 0)) {
  308.                   return (FILE *)NULL;
  309.                }
  310.                if((in = fopen(buf,READ_TEXT)) != NULLFILE) {
  311.                   fclose(in);
  312.                   mailcat(buf,specific);
  313.                   reqcnt++;
  314.                } else
  315.                   mailcat(error,"File Not Found!");
  316.             }
  317.          } 
  318.       } else {
  319.          sprintf(buf,"%s/retrieve",Digger);
  320.          mailcat(buf,"retrieve");
  321.          reqcnt++;
  322.       }
  323.  
  324.    return 0;
  325. }
  326.  
  327. static int sendhelp(argc,argv,p)
  328. int argc;
  329. char *argv[];
  330. void *p;
  331. {
  332.    char buf[100];
  333.  
  334.    if(reqcnt < MaxReq) {
  335.       mainlog(-1,"Digger: Help Requested By '%s'", whoto);
  336.       sprintf(buf,"%s/help",Digger);
  337.       mailcat(buf,argv[0]);
  338.       reqcnt++;
  339.    }
  340.    return 0;
  341. }
  342.  
  343. static int sendindex(argc,argv,p)
  344. int argc;
  345. char *argv[];
  346. void *p;
  347. {
  348.    char buf[100], command[100], error[100], *archive;
  349.  
  350.    archive = (argv[1] == NULLCHAR) ? "DataBase" : argv[1];
  351.  
  352.    if(reqcnt < MaxReq) 
  353.       if(strstr(archive,"*") == NULL) {
  354.          mainlog(-1,"Digger: Index '%s' For '%s'", archive, whoto);
  355.          sprintf(command, "LHA >%s/index -N l %s/%s", Digger, Digger, archive);
  356.          if (!Execute(command, 0, 0)) {
  357.             return (FILE *)NULL;
  358.          }
  359.          sprintf(buf,"%s/index", Digger);
  360.          mailcat(buf,archive);
  361.          reqcnt++;
  362.       } else {
  363.          sprintf(error,"%s/error", Digger);
  364.          mailcat(error,"Wild Cards Not Permitted!");
  365.       }
  366.  
  367.    return 0;
  368. }
  369.  
  370. static int listarchives(argc,argv,p)
  371. int argc;
  372. char *argv[];
  373. void *p;
  374. {
  375.    char buf[100];
  376.  
  377.    if(reqcnt < MaxReq) {
  378.       mainlog(-1,"Digger: Archives Requested By '%s'", whoto);
  379.       sprintf(buf,"%s/archives",Digger);
  380.       mailcat(buf,argv[0]);
  381.       reqcnt++;
  382.    }
  383.  
  384.    return 0;
  385. }
  386.  
  387. /* Given the person to mail it to, and a file name, this opens the file
  388.    and mails the contents to the specified user. */
  389. static int mailcat(file,explanation)
  390. char *file, *explanation;
  391. {
  392.    FILE *in, *out;
  393.    char fn[50], subject[50];
  394.    int data, bcount=0, partno = 1;
  395.  
  396.    in = fopen(file,"r");
  397.  
  398.    while ((data = fgetc(in)) != EOF) {
  399.       out = fopen("t:smtptemp.fil","w+");
  400.       if (in == NULL || out == NULL) return -1;
  401.       sprintf(subject,"%s - %d",explanation,partno);
  402.       AddSMTPHeader(out,subject);
  403.       if((bcount%MaxSeg == 0) && (bcount != 0))
  404.      fprintf(out,"[Continued from Part %d]\n\n",partno - 1);
  405.       fputc(data,out);
  406.       bcount++;
  407.       while (((data = fgetc(in)) != EOF) && (bcount%MaxSeg != 0)) {
  408.          fputc(data,out);
  409.          bcount++;
  410.       }
  411.       if(bcount%MaxSeg == 0) {
  412.          fputc(data,out);
  413.          partno++;
  414.          fprintf(out,"\n\n[Continued in Part %d]\n",partno);
  415.       }
  416.       rewind(out);
  417.  
  418.       sprintf(fn,"Digger@%s",Hostname);
  419.       mailuser(out,fn,whoto);
  420.  
  421.       fclose(out);
  422.       unlink("t:smtptemp.fil");
  423.    }
  424.    fclose(in);
  425.  
  426.    return 0;
  427. }
  428.  
  429. /* Given an open file pointer, this tacks on the proper SMTP header. */
  430. static int AddSMTPHeader(tfile,explanation)
  431. FILE *tfile;
  432. char *explanation;
  433. {
  434.    time_t t;
  435.    char buf[AXALEN], *mynic, *cp, *cp2, newto[80];
  436.    int32 id;
  437.  
  438.    if (tfile != NULLFILE) {
  439.  
  440.       pax25(buf,Mycall);
  441.       if((cp=strchr(buf,'-')) != NULLCHAR)
  442.          *cp = '\0';
  443.  
  444.       if (RHdr != NULLCHAR) {
  445.          mynic = strdup(RHdr);
  446.          if((cp2=strchr(mynic,' ')) != NULLCHAR)
  447.             *cp2 = '\0';
  448.       }
  449.     
  450.       time(&t);
  451.       id = get_msgid();
  452.  
  453.       fprintf(tfile,"%s%s",Hdrs[DATE],ptime(&t));
  454.       fprintf(tfile,"%s<%ld@%s>\n",Hdrs[MSGID], id, Hostname);
  455.  
  456.       fprintf(tfile,"%s%s@%s (%s)\n", Hdrs[FROM],
  457.          strlen(buf) ? buf : "Digger",
  458.          strlen(buf) ? (strlen(mynic) ? mynic : Hostname) : Hostname,
  459.          strlen(buf) ? "Digger" : "File Server");
  460.  
  461.       if (Organ != NULLCHAR)
  462.          fprintf(tfile,"%s%s\n",Hdrs[ORGANISATION],Organ);
  463.  
  464.       if(FoundRColon) {
  465.          if((cp2=strchr(whoto,'%')) != NULLCHAR)
  466.             *cp2 = '\0';
  467.          if((cp2=strchr(whoto,'@')) != NULLCHAR)
  468.             *cp2 = '\0';
  469.  
  470.          if((cp2=strchr(tonic,':')) != NULLCHAR)
  471.             cp2 = &tonic[2];
  472.          else
  473.             cp2 = &tonic[1];
  474.  
  475.          sprintf(newto, "%s@%s", whoto, cp2);
  476.          fprintf(tfile,"To: %s\n",newto);
  477.  
  478.       } else
  479.  
  480.          fprintf(tfile,"To: %s\n",whoto);
  481.  
  482.       fprintf(tfile,"%sRe: '%s'\n", Hdrs[SUBJECT], explanation);
  483.       fprintf(tfile,"%sAmigaNOS v%s\n",Hdrs[COMMENT],Version);
  484.       fprintf(tfile,"\n");
  485.       if (RHdr != NULLCHAR)
  486.          fprintf(tfile,"R:%s @:%s #:%ld\n\n",
  487.                  mbxtime(ptime(&t)), RHdr, id);
  488.    } else return -1;
  489. }
  490.